/**
 * Request 1.0.3
 * @Class Request
 * @description luch-request 1.0.3 http请求插件
 * @Author lu-ch
 * @Date 2019-11-01
 * @Email webwork.s@qq.com
 * http://ext.dcloud.net.cn/plugin?id=392
 */

import { reqType, reqMethod, reqJiaMi, reqLoading, reqSync } from "@/config";
export default class Request {
  config = {
    baseUrl: "",
    header: {
      "content-type": "application/json;charset=UTF-8",
    },
    method: reqMethod,
    dataType: "json",
    responseType: "text",
    loading: reqLoading,
    sync: reqSync,
    jiami: reqJiaMi,
    reqType: reqType,
    // #ifdef APP-PLUS
    sslVerify: true,
    // #endif
  };

  static posUrl(url) {
    /* 判断url是否为绝对路径 */
    return /(http|https):\/\/([\w.]+\/?)\S*/.test(url);
  }

  static addQueryString(params) {
    let paramsData = "";
    Object.keys(params).forEach(function (key) {
      paramsData += key + "=" + encodeURIComponent(params[key]) + "&";
    });
    return paramsData.substring(0, paramsData.length - 1);
  }

  /**
   * @property {Function} request 请求拦截器
   * @property {Function} response 响应拦截器
   * @type {{request: Request.interceptor.request, response: Request.interceptor.response}}
   */
  interceptor = {
    /**
     * @param {Request~requestCallback} cb - 请求之前拦截,接收一个函数（config, cancel）=> {return config}。第一个参数为全局config,第二个参数为函数，调用则取消本次请求。
     */
    request: (cb) => {
      if (cb) {
        this.requestBeforeFun = cb;
      }
    },
    /**
     * @param {Request~responseCallback} cb 响应拦截器，对响应数据做点什么
     * @param {Request~responseErrCallback} ecb 响应拦截器，对响应错误做点什么
     */
    response: (cb, ecb) => {
      if (cb && ecb) {
        this.requestComFun = cb;
        this.requestComFail = ecb;
      }
    },
  };

  requestBeforeFun(config) {
    return config;
  }

  requestComFun(response) {
    return response;
  }

  requestComFail(response) {
    return response;
  }

  /**
   * 自定义验证器，如果返回true 则进入响应拦截器的响应成功函数(resolve)，否则进入响应拦截器的响应错误函数(reject)
   * @param { Number } statusCode - 请求响应体statusCode（只读）
   * @return { Boolean } 如果为true,则 resolve, 否则 reject
   */
  validateStatus(statusCode) {
    return statusCode === 200;
  }

  /**
   * @Function
   * @param {Request~setConfigCallback} f - 设置全局默认配置
   */
  setConfig(f) {
    this.config = f(this.config);
  }

  /**
   * @Function
   * @param {Object} options - 请求配置项
   * @prop {String} options.url - 请求路径
   * @prop {Object} options.data - 请求参数
   * @prop {Object} [options.responseType = config.responseType] [text|arraybuffer] - 响应的数据类型
   * @prop {Object} [options.dataType = config.dataType] - 如果设为 json，会尝试对返回的数据做一次 JSON.parse
   * @prop {Object} [options.header = config.header] - 请求header
   * @prop {Object} [options.method = config.method] - 请求方法
   * @returns {Promise<unknown>}
   */
  async request(options = {}) {
    options.baseUrl = options.baseUrl || this.config.baseUrl;
    options.dataType = options.dataType || this.config.dataType;
    options.responseType = options.responseType || this.config.responseType;
    options.url = options.url || "";
    options.loading = 'loading' in options ? options.loading : this.config.loading;
    options.sync = 'sync' in options ? options.sync : this.config.sync;
    options.jiami = 'jiami' in options ? options.jiami : this.config.jiami;
    options.reqType = options.reqType || this.config.reqType;
    options.data = options.data || {};
    options.params = options.params || {};
    options.header = options.header || JSON.parse(JSON.stringify(this.config.header));
    options.method = options.method || this.config.method;
    if (options.reqType == "form") {
      options.header["content-type"] = "application/x-www-form-urlencoded";
    }
    // #ifdef APP-PLUS
    options.sslVerify =
      options.sslVerify === undefined
        ? this.config.sslVerify
        : options.sslVerify;
    // #endif
    return new Promise((resolve, reject) => {
      let next = true;

      let handleRe = {};
      options.complete = (response) => {
        uni.hideLoading(); // 隐藏加载动画
        uni.hideLoading(); // 隐藏加载动画
        uni.stopPullDownRefresh(); // 结束下拉请求动画
        uni.stopPullDownRefresh(); // 结束下拉请求动画
        response.config = handleRe;
        if (this.validateStatus(response.statusCode)) {
          // 成功
          response = this.requestComFun(response);
          resolve(response);
        } else {
          response = this.requestComFail(response);
          reject(response);
        }
      };
      const cancel = (t = "handle cancel", config = options) => {
        // const err = {
        //   errMsg: t,
        //   config: config,
        // };
        reject(t);
        next = false;
      };

      handleRe = { ...this.requestBeforeFun(options, cancel) };
      const _config = { ...handleRe };
      if (!next) return;

      let mergeUrl = Request.posUrl(options.url)
        ? options.url
        : options.baseUrl + options.url;
      if (JSON.stringify(options.params) !== "{}") {
        const paramsH = Request.addQueryString(options.params);
        mergeUrl +=
          mergeUrl.indexOf("?") === -1 ? `?${paramsH}` : `&${paramsH}`;
      }
      _config.sslVerify = false;
      _config.url = mergeUrl;
      uni.request(_config);
    });
  }

  get(url, options = {}) {
    return this.request({
      url,
      method: "GET",
      ...options,
    });
  }

  post(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: "POST",
      ...options,
    });
  }

  // #ifndef MP-ALIPAY
  put(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: "PUT",
      ...options,
    });
  }

  // #endif

  // #ifdef APP-PLUS || H5 || MP-WEIXIN || MP-BAIDU
  delete(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: "DELETE",
      ...options,
    });
  }

  // #endif

  // #ifdef APP-PLUS || H5 || MP-WEIXIN
  connect(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: "CONNECT",
      ...options,
    });
  }

  // #endif

  // #ifdef APP-PLUS || H5 || MP-WEIXIN || MP-BAIDU
  head(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: "HEAD",
      ...options,
    });
  }

  // #endif

  // #ifdef APP-PLUS || H5 || MP-WEIXIN || MP-BAIDU
  options(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: "OPTIONS",
      ...options,
    });
  }

  // #endif

  // #ifdef APP-PLUS || H5 || MP-WEIXIN
  trace(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: "TRACE",
      ...options,
    });
  }

  // #endif

  upload(
    url,
    {
      // #ifdef APP-PLUS
      files,
      // #endif
      // #ifdef MP-ALIPAY
      fileType,
      // #endif
      filePath,
      dataType = this.config.dataType,
      name,
      header,
      formData,
    }
  ) {
    return new Promise((resolve, reject) => {
      let next = true;
      let handleRe = {};
      const globalHeader = { ...this.config.header };
      delete globalHeader["content-type"];
      let pubConfig = {
        baseUrl: this.config.baseUrl,
        url,
        // #ifdef APP-PLUS
        files,
        // #endif
        // #ifdef MP-ALIPAY
        fileType,
        // #endif
        filePath,
        method: "UPLOAD",
        name,
        dataType,
        header: header || globalHeader,
        formData,
        complete: (response) => {
          response.config = handleRe;
          uni.hideLoading(); // 隐藏加载动画
          uni.hideLoading(); // 隐藏加载动画
          uni.stopPullDownRefresh(); // 结束下拉请求动画
          uni.stopPullDownRefresh(); // 结束下拉请求动画
          if (response.statusCode === 200) {
            // 成功
            if (handleRe.dataType == "json") {
              try {
                response.data = JSON.parse(response.data);
              } catch (err) {}
            }
            response = this.requestComFun(response);
            resolve(response);
          } else {
            response = this.requestComFail(response);
            reject(response);
          }
        },
      };
      pubConfig = Object.assign({}, this.config, pubConfig);
      const cancel = (t = "handle cancel", config = pubConfig) => {
        const err = {
          errMsg: t,
          config: config,
        };
        reject(err);
        next = false;
      };

      handleRe = { ...this.requestBeforeFun(pubConfig, cancel) };
      const _config = { ...handleRe };
      if (!next) return;
      _config.url = Request.posUrl(url) ? url : _config.baseUrl + url;
      uni.uploadFile(_config);
    });
  }
}

/**
 * setConfig回调
 * @return {Object} - 返回操作后的config
 * @callback Request~setConfigCallback
 * @param {Object} config - 全局默认config
 */
/**
 * 请求拦截器回调
 * @return {Object} - 返回操作后的config
 * @callback Request~requestCallback
 * @param {Object} config - 全局config
 * @param {Function} [cancel] - 取消请求钩子，调用会取消本次请求
 */
/**
 * 响应拦截器回调
 * @return {Object} - 返回操作后的response
 * @callback Request~responseCallback
 * @param {Object} response - 请求结果 response
 */
/**
 * 响应错误拦截器回调
 * @return {Object} - 返回操作后的response
 * @callback Request~responseErrCallback
 * @param {Object} response - 请求结果 response
 */
